<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="Start" href="index.html">
<link rel="previous" href="Builtin_attributes.html">
<link rel="next" href="BytesLabels.html">
<link rel="Up" href="index.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
<link title="Index of values" rel=Appendix href="index_values.html">
<link title="Index of modules" rel=Appendix href="index_modules.html">
<link title="Index of module types" rel=Appendix href="index_module_types.html">
<link title="Arg" rel="Chapter" href="Arg.html">
<link title="Arg_helper" rel="Chapter" href="Arg_helper.html">
<link title="Array" rel="Chapter" href="Array.html">
<link title="ArrayLabels" rel="Chapter" href="ArrayLabels.html">
<link title="Ast_helper" rel="Chapter" href="Ast_helper.html">
<link title="Ast_invariants" rel="Chapter" href="Ast_invariants.html">
<link title="Ast_iterator" rel="Chapter" href="Ast_iterator.html">
<link title="Ast_mapper" rel="Chapter" href="Ast_mapper.html">
<link title="Asttypes" rel="Chapter" href="Asttypes.html">
<link title="Attr_helper" rel="Chapter" href="Attr_helper.html">
<link title="Bigarray" rel="Chapter" href="Bigarray.html">
<link title="Buffer" rel="Chapter" href="Buffer.html">
<link title="Builtin_attributes" rel="Chapter" href="Builtin_attributes.html">
<link title="Bytes" rel="Chapter" href="Bytes.html">
<link title="BytesLabels" rel="Chapter" href="BytesLabels.html">
<link title="Callback" rel="Chapter" href="Callback.html">
<link title="CamlinternalFormat" rel="Chapter" href="CamlinternalFormat.html">
<link title="CamlinternalFormatBasics" rel="Chapter" href="CamlinternalFormatBasics.html">
<link title="CamlinternalLazy" rel="Chapter" href="CamlinternalLazy.html">
<link title="CamlinternalMod" rel="Chapter" href="CamlinternalMod.html">
<link title="CamlinternalOO" rel="Chapter" href="CamlinternalOO.html">
<link title="Ccomp" rel="Chapter" href="Ccomp.html">
<link title="Char" rel="Chapter" href="Char.html">
<link title="Clflags" rel="Chapter" href="Clflags.html">
<link title="Complex" rel="Chapter" href="Complex.html">
<link title="Condition" rel="Chapter" href="Condition.html">
<link title="Config" rel="Chapter" href="Config.html">
<link title="Consistbl" rel="Chapter" href="Consistbl.html">
<link title="Depend" rel="Chapter" href="Depend.html">
<link title="Digest" rel="Chapter" href="Digest.html">
<link title="Docstrings" rel="Chapter" href="Docstrings.html">
<link title="Dynlink" rel="Chapter" href="Dynlink.html">
<link title="Ephemeron" rel="Chapter" href="Ephemeron.html">
<link title="Event" rel="Chapter" href="Event.html">
<link title="Filename" rel="Chapter" href="Filename.html">
<link title="Format" rel="Chapter" href="Format.html">
<link title="Gc" rel="Chapter" href="Gc.html">
<link title="Genlex" rel="Chapter" href="Genlex.html">
<link title="Graphics" rel="Chapter" href="Graphics.html">
<link title="GraphicsX11" rel="Chapter" href="GraphicsX11.html">
<link title="Hashtbl" rel="Chapter" href="Hashtbl.html">
<link title="Identifiable" rel="Chapter" href="Identifiable.html">
<link title="Int32" rel="Chapter" href="Int32.html">
<link title="Int64" rel="Chapter" href="Int64.html">
<link title="Lazy" rel="Chapter" href="Lazy.html">
<link title="Lexer" rel="Chapter" href="Lexer.html">
<link title="Lexing" rel="Chapter" href="Lexing.html">
<link title="List" rel="Chapter" href="List.html">
<link title="ListLabels" rel="Chapter" href="ListLabels.html">
<link title="Location" rel="Chapter" href="Location.html">
<link title="Longident" rel="Chapter" href="Longident.html">
<link title="Map" rel="Chapter" href="Map.html">
<link title="Marshal" rel="Chapter" href="Marshal.html">
<link title="Misc" rel="Chapter" href="Misc.html">
<link title="MoreLabels" rel="Chapter" href="MoreLabels.html">
<link title="Mutex" rel="Chapter" href="Mutex.html">
<link title="Nativeint" rel="Chapter" href="Nativeint.html">
<link title="Numbers" rel="Chapter" href="Numbers.html">
<link title="Obj" rel="Chapter" href="Obj.html">
<link title="Oo" rel="Chapter" href="Oo.html">
<link title="Parse" rel="Chapter" href="Parse.html">
<link title="Parser" rel="Chapter" href="Parser.html">
<link title="Parsetree" rel="Chapter" href="Parsetree.html">
<link title="Parsing" rel="Chapter" href="Parsing.html">
<link title="Pervasives" rel="Chapter" href="Pervasives.html">
<link title="Pparse" rel="Chapter" href="Pparse.html">
<link title="Pprintast" rel="Chapter" href="Pprintast.html">
<link title="Printast" rel="Chapter" href="Printast.html">
<link title="Printexc" rel="Chapter" href="Printexc.html">
<link title="Printf" rel="Chapter" href="Printf.html">
<link title="Profile" rel="Chapter" href="Profile.html">
<link title="Queue" rel="Chapter" href="Queue.html">
<link title="Random" rel="Chapter" href="Random.html">
<link title="Scanf" rel="Chapter" href="Scanf.html">
<link title="Set" rel="Chapter" href="Set.html">
<link title="Simplif" rel="Chapter" href="Simplif.html">
<link title="Sort" rel="Chapter" href="Sort.html">
<link title="Spacetime" rel="Chapter" href="Spacetime.html">
<link title="Stack" rel="Chapter" href="Stack.html">
<link title="StdLabels" rel="Chapter" href="StdLabels.html">
<link title="Str" rel="Chapter" href="Str.html">
<link title="Stream" rel="Chapter" href="Stream.html">
<link title="String" rel="Chapter" href="String.html">
<link title="StringLabels" rel="Chapter" href="StringLabels.html">
<link title="Strongly_connected_components" rel="Chapter" href="Strongly_connected_components.html">
<link title="Syntaxerr" rel="Chapter" href="Syntaxerr.html">
<link title="Sys" rel="Chapter" href="Sys.html">
<link title="Targetint" rel="Chapter" href="Targetint.html">
<link title="Tbl" rel="Chapter" href="Tbl.html">
<link title="Terminfo" rel="Chapter" href="Terminfo.html">
<link title="Thread" rel="Chapter" href="Thread.html">
<link title="ThreadUnix" rel="Chapter" href="ThreadUnix.html">
<link title="Typemod" rel="Chapter" href="Typemod.html">
<link title="Uchar" rel="Chapter" href="Uchar.html">
<link title="Unix" rel="Chapter" href="Unix.html">
<link title="UnixLabels" rel="Chapter" href="UnixLabels.html">
<link title="Warnings" rel="Chapter" href="Warnings.html">
<link title="Weak" rel="Chapter" href="Weak.html"><link title="Unsafe conversions (for advanced users)" rel="Section" href="#3_Unsafeconversionsforadvancedusers">
<title>Bytes</title>
</head>
<body>
<div class="navbar"><a class="pre" href="Builtin_attributes.html" title="Builtin_attributes">Previous</a>
&nbsp;<a class="up" href="index.html" title="Index">Up</a>
&nbsp;<a class="post" href="BytesLabels.html" title="BytesLabels">Next</a>
</div>
<h1>Module <a href="type_Bytes.html">Bytes</a></h1>

<pre><span id="MODULEBytes"><span class="keyword">module</span> Bytes</span>: <code class="code"><span class="keyword">sig</span></code> <a href="Bytes.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info module top">
<div class="info-desc">
<p>Byte sequence operations.</p>

<p>A byte sequence is a mutable data structure that contains a
   fixed-length sequence of bytes. Each byte can be indexed in
   constant time for reading or writing.</p>

<p>Given a byte sequence <code class="code">s</code> of length <code class="code">l</code>, we can access each of the
   <code class="code">l</code> bytes of <code class="code">s</code> via its index in the sequence. Indexes start at
   <code class="code">0</code>, and we will call an index valid in <code class="code">s</code> if it falls within the
   range <code class="code">[0...l-1]</code> (inclusive). A position is the point between two
   bytes or at the beginning or end of the sequence.  We call a
   position valid in <code class="code">s</code> if it falls within the range <code class="code">[0...l]</code>
   (inclusive). Note that the byte at index <code class="code">n</code> is between positions
   <code class="code">n</code> and <code class="code">n+1</code>.</p>

<p>Two parameters <code class="code">start</code> and <code class="code">len</code> are said to designate a valid
   range of <code class="code">s</code> if <code class="code">len&nbsp;&gt;=&nbsp;0</code> and <code class="code">start</code> and <code class="code">start+len</code> are valid
   positions in <code class="code">s</code>.</p>

<p>Byte sequences can be modified in place, for instance via the <code class="code">set</code>
   and <code class="code">blit</code> functions described below.  See also strings (module
   <a href="String.html"><code class="code"><span class="constructor">String</span></code></a>), which are almost the same data structure, but cannot be
   modified in place.</p>

<p>Bytes are represented by the OCaml type <code class="code">char</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.02.0</li>
</ul>
</div>
<hr width="100%">

<pre><span id="VALlength"><span class="keyword">val</span> length</span> : <code class="type">bytes -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Return the length (number of bytes) of the argument.</p>
</div>
</div>

<pre><span id="VALget"><span class="keyword">val</span> get</span> : <code class="type">bytes -> int -> char</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">get&nbsp;s&nbsp;n</code> returns the byte at index <code class="code">n</code> in argument <code class="code">s</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">n</code> is not a valid index in <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALset"><span class="keyword">val</span> set</span> : <code class="type">bytes -> int -> char -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">set&nbsp;s&nbsp;n&nbsp;c</code> modifies <code class="code">s</code> in place, replacing the byte at index <code class="code">n</code>
    with <code class="code">c</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">n</code> is not a valid index in <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALcreate"><span class="keyword">val</span> create</span> : <code class="type">int -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">create&nbsp;n</code> returns a new byte sequence of length <code class="code">n</code>. The
    sequence is uninitialized and contains arbitrary bytes.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">n&nbsp;&lt;&nbsp;0</code> or <code class="code">n&nbsp;&gt;&nbsp;</code><a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a>.</p>
</div>
</div>

<pre><span id="VALmake"><span class="keyword">val</span> make</span> : <code class="type">int -> char -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">make&nbsp;n&nbsp;c</code> returns a new byte sequence of length <code class="code">n</code>, filled with
    the byte <code class="code">c</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">n&nbsp;&lt;&nbsp;0</code> or <code class="code">n&nbsp;&gt;&nbsp;</code><a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a>.</p>
</div>
</div>

<pre><span id="VALinit"><span class="keyword">val</span> init</span> : <code class="type">int -> (int -> char) -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Bytes</span>.init&nbsp;n&nbsp;f</code> returns a fresh byte sequence of length <code class="code">n</code>, with
    character <code class="code">i</code> initialized to the result of <code class="code">f&nbsp;i</code> (in increasing
    index order).</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">n&nbsp;&lt;&nbsp;0</code> or <code class="code">n&nbsp;&gt;&nbsp;</code><a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a>.</p>
</div>
</div>

<pre><span id="VALempty"><span class="keyword">val</span> empty</span> : <code class="type">bytes</code></pre><div class="info ">
<div class="info-desc">
<p>A byte sequence of size 0.</p>
</div>
</div>

<pre><span id="VALcopy"><span class="keyword">val</span> copy</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p>Return a new byte sequence that contains the same bytes as the
    argument.</p>
</div>
</div>

<pre><span id="VALof_string"><span class="keyword">val</span> of_string</span> : <code class="type">string -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p>Return a new byte sequence that contains the same bytes as the
    given string.</p>
</div>
</div>

<pre><span id="VALto_string"><span class="keyword">val</span> to_string</span> : <code class="type">bytes -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Return a new string that contains the same bytes as the given byte
    sequence.</p>
</div>
</div>

<pre><span id="VALsub"><span class="keyword">val</span> sub</span> : <code class="type">bytes -> int -> int -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">sub&nbsp;s&nbsp;start&nbsp;len</code> returns a new byte sequence of length <code class="code">len</code>,
    containing the subsequence of <code class="code">s</code> that starts at position <code class="code">start</code>
    and has length <code class="code">len</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">start</code> and <code class="code">len</code> do not designate a
    valid range of <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALsub_string"><span class="keyword">val</span> sub_string</span> : <code class="type">bytes -> int -> int -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Same as <code class="code">sub</code> but return a string instead of a byte sequence.</p>
</div>
</div>

<pre><span id="VALextend"><span class="keyword">val</span> extend</span> : <code class="type">bytes -> int -> int -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">extend&nbsp;s&nbsp;left&nbsp;right</code> returns a new byte sequence that contains
    the bytes of <code class="code">s</code>, with <code class="code">left</code> uninitialized bytes prepended and
    <code class="code">right</code> uninitialized bytes appended to it. If <code class="code">left</code> or <code class="code">right</code>
    is negative, then bytes are removed (instead of appended) from
    the corresponding side of <code class="code">s</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if the result length is negative or
    longer than <a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a> bytes.</p>
</div>
</div>

<pre><span id="VALfill"><span class="keyword">val</span> fill</span> : <code class="type">bytes -> int -> int -> char -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">fill&nbsp;s&nbsp;start&nbsp;len&nbsp;c</code> modifies <code class="code">s</code> in place, replacing <code class="code">len</code>
    characters with <code class="code">c</code>, starting at <code class="code">start</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">start</code> and <code class="code">len</code> do not designate a
    valid range of <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALblit"><span class="keyword">val</span> blit</span> : <code class="type">bytes -> int -> bytes -> int -> int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">blit&nbsp;src&nbsp;srcoff&nbsp;dst&nbsp;dstoff&nbsp;len</code> copies <code class="code">len</code> bytes from sequence
    <code class="code">src</code>, starting at index <code class="code">srcoff</code>, to sequence <code class="code">dst</code>, starting at
    index <code class="code">dstoff</code>. It works correctly even if <code class="code">src</code> and <code class="code">dst</code> are the
    same byte sequence, and the source and destination intervals
    overlap.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">srcoff</code> and <code class="code">len</code> do not
    designate a valid range of <code class="code">src</code>, or if <code class="code">dstoff</code> and <code class="code">len</code>
    do not designate a valid range of <code class="code">dst</code>.</p>
</div>
</div>

<pre><span id="VALblit_string"><span class="keyword">val</span> blit_string</span> : <code class="type">string -> int -> bytes -> int -> int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">blit&nbsp;src&nbsp;srcoff&nbsp;dst&nbsp;dstoff&nbsp;len</code> copies <code class="code">len</code> bytes from string
    <code class="code">src</code>, starting at index <code class="code">srcoff</code>, to byte sequence <code class="code">dst</code>,
    starting at index <code class="code">dstoff</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">srcoff</code> and <code class="code">len</code> do not
    designate a valid range of <code class="code">src</code>, or if <code class="code">dstoff</code> and <code class="code">len</code>
    do not designate a valid range of <code class="code">dst</code>.</p>
</div>
</div>

<pre><span id="VALconcat"><span class="keyword">val</span> concat</span> : <code class="type">bytes -> bytes list -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">concat&nbsp;sep&nbsp;sl</code> concatenates the list of byte sequences <code class="code">sl</code>,
    inserting the separator byte sequence <code class="code">sep</code> between each, and
    returns the result as a new byte sequence.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if the result is longer than
    <a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a> bytes.</p>
</div>
</div>

<pre><span id="VALcat"><span class="keyword">val</span> cat</span> : <code class="type">bytes -> bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">cat&nbsp;s1&nbsp;s2</code> concatenates <code class="code">s1</code> and <code class="code">s2</code> and returns the result
     as new byte sequence.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if the result is longer than
    <a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a> bytes.</p>
</div>
</div>

<pre><span id="VALiter"><span class="keyword">val</span> iter</span> : <code class="type">(char -> unit) -> bytes -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">iter&nbsp;f&nbsp;s</code> applies function <code class="code">f</code> in turn to all the bytes of <code class="code">s</code>.
    It is equivalent to <code class="code">f&nbsp;(get&nbsp;s&nbsp;0);&nbsp;f&nbsp;(get&nbsp;s&nbsp;1);&nbsp;...;&nbsp;f&nbsp;(get&nbsp;s<br>
&nbsp;&nbsp;&nbsp;&nbsp;(length&nbsp;s&nbsp;-&nbsp;1));&nbsp;()</code>.</p>
</div>
</div>

<pre><span id="VALiteri"><span class="keyword">val</span> iteri</span> : <code class="type">(int -> char -> unit) -> bytes -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Same as <a href="Bytes.html#VALiter"><code class="code"><span class="constructor">Bytes</span>.iter</code></a>, but the function is applied to the index of
    the byte as first argument and the byte itself as second
    argument.</p>
</div>
</div>

<pre><span id="VALmap"><span class="keyword">val</span> map</span> : <code class="type">(char -> char) -> bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">map&nbsp;f&nbsp;s</code> applies function <code class="code">f</code> in turn to all the bytes of <code class="code">s</code>
    (in increasing index order) and stores the resulting bytes in
    a new sequence that is returned as the result.</p>
</div>
</div>

<pre><span id="VALmapi"><span class="keyword">val</span> mapi</span> : <code class="type">(int -> char -> char) -> bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">mapi&nbsp;f&nbsp;s</code> calls <code class="code">f</code> with each character of <code class="code">s</code> and its
    index (in increasing index order) and stores the resulting bytes
    in a new sequence that is returned as the result.</p>
</div>
</div>

<pre><span id="VALtrim"><span class="keyword">val</span> trim</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, without leading and trailing
    whitespace. The bytes regarded as whitespace are the ASCII
    characters <code class="code"><span class="string">'&nbsp;'</span></code>, <code class="code"><span class="string">'\012'</span></code>, <code class="code"><span class="string">'\n'</span></code>, <code class="code"><span class="string">'\r'</span></code>, and <code class="code"><span class="string">'\t'</span></code>.</p>
</div>
</div>

<pre><span id="VALescaped"><span class="keyword">val</span> escaped</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with special characters represented
    by escape sequences, following the lexical conventions of OCaml.
    All characters outside the ASCII printable range (32..126) are
    escaped, as well as backslash and double-quote.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if the result is longer than
    <a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a> bytes.</p>
</div>
</div>

<pre><span id="VALindex"><span class="keyword">val</span> index</span> : <code class="type">bytes -> char -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">index&nbsp;s&nbsp;c</code> returns the index of the first occurrence of byte <code class="code">c</code>
    in <code class="code">s</code>.</p>

<p>Raise <code class="code"><span class="constructor">Not_found</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALindex_opt"><span class="keyword">val</span> index_opt</span> : <code class="type">bytes -> char -> int option</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">index_opt&nbsp;s&nbsp;c</code> returns the index of the first occurrence of byte <code class="code">c</code>
    in <code class="code">s</code> or <code class="code"><span class="constructor">None</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05</li>
</ul>
</div>

<pre><span id="VALrindex"><span class="keyword">val</span> rindex</span> : <code class="type">bytes -> char -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">rindex&nbsp;s&nbsp;c</code> returns the index of the last occurrence of byte <code class="code">c</code>
    in <code class="code">s</code>.</p>

<p>Raise <code class="code"><span class="constructor">Not_found</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALrindex_opt"><span class="keyword">val</span> rindex_opt</span> : <code class="type">bytes -> char -> int option</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">rindex_opt&nbsp;s&nbsp;c</code> returns the index of the last occurrence of byte <code class="code">c</code>
    in <code class="code">s</code> or <code class="code"><span class="constructor">None</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05</li>
</ul>
</div>

<pre><span id="VALindex_from"><span class="keyword">val</span> index_from</span> : <code class="type">bytes -> int -> char -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">index_from&nbsp;s&nbsp;i&nbsp;c</code> returns the index of the first occurrence of
    byte <code class="code">c</code> in <code class="code">s</code> after position <code class="code">i</code>.  <code class="code"><span class="constructor">Bytes</span>.index&nbsp;s&nbsp;c</code> is
    equivalent to <code class="code"><span class="constructor">Bytes</span>.index_from&nbsp;s&nbsp;0&nbsp;c</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">i</code> is not a valid position in <code class="code">s</code>.
    Raise <code class="code"><span class="constructor">Not_found</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code> after position <code class="code">i</code>.</p>
</div>
</div>

<pre><span id="VALindex_from_opt"><span class="keyword">val</span> index_from_opt</span> : <code class="type">bytes -> int -> char -> int option</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">index_from&nbsp;_opts&nbsp;i&nbsp;c</code> returns the index of the first occurrence of
    byte <code class="code">c</code> in <code class="code">s</code> after position <code class="code">i</code> or <code class="code"><span class="constructor">None</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code> after position <code class="code">i</code>.
    <code class="code"><span class="constructor">Bytes</span>.index_opt&nbsp;s&nbsp;c</code> is equivalent to <code class="code"><span class="constructor">Bytes</span>.index_from_opt&nbsp;s&nbsp;0&nbsp;c</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">i</code> is not a valid position in <code class="code">s</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05</li>
</ul>
</div>

<pre><span id="VALrindex_from"><span class="keyword">val</span> rindex_from</span> : <code class="type">bytes -> int -> char -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">rindex_from&nbsp;s&nbsp;i&nbsp;c</code> returns the index of the last occurrence of
    byte <code class="code">c</code> in <code class="code">s</code> before position <code class="code">i+1</code>.  <code class="code">rindex&nbsp;s&nbsp;c</code> is equivalent
    to <code class="code">rindex_from&nbsp;s&nbsp;(<span class="constructor">Bytes</span>.length&nbsp;s&nbsp;-&nbsp;1)&nbsp;c</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">i+1</code> is not a valid position in <code class="code">s</code>.
    Raise <code class="code"><span class="constructor">Not_found</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code> before position <code class="code">i+1</code>.</p>
</div>
</div>

<pre><span id="VALrindex_from_opt"><span class="keyword">val</span> rindex_from_opt</span> : <code class="type">bytes -> int -> char -> int option</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">rindex_from_opt&nbsp;s&nbsp;i&nbsp;c</code> returns the index of the last occurrence
    of byte <code class="code">c</code> in <code class="code">s</code> before position <code class="code">i+1</code> or <code class="code"><span class="constructor">None</span></code> if <code class="code">c</code> does not
    occur in <code class="code">s</code> before position <code class="code">i+1</code>.  <code class="code">rindex_opt&nbsp;s&nbsp;c</code> is equivalent to
    <code class="code">rindex_from&nbsp;s&nbsp;(<span class="constructor">Bytes</span>.length&nbsp;s&nbsp;-&nbsp;1)&nbsp;c</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">i+1</code> is not a valid position in <code class="code">s</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05</li>
</ul>
</div>

<pre><span id="VALcontains"><span class="keyword">val</span> contains</span> : <code class="type">bytes -> char -> bool</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">contains&nbsp;s&nbsp;c</code> tests if byte <code class="code">c</code> appears in <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALcontains_from"><span class="keyword">val</span> contains_from</span> : <code class="type">bytes -> int -> char -> bool</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">contains_from&nbsp;s&nbsp;start&nbsp;c</code> tests if byte <code class="code">c</code> appears in <code class="code">s</code> after
    position <code class="code">start</code>.  <code class="code">contains&nbsp;s&nbsp;c</code> is equivalent to <code class="code">contains_from<br>
&nbsp;&nbsp;&nbsp;&nbsp;s&nbsp;0&nbsp;c</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">start</code> is not a valid position in <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALrcontains_from"><span class="keyword">val</span> rcontains_from</span> : <code class="type">bytes -> int -> char -> bool</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">rcontains_from&nbsp;s&nbsp;stop&nbsp;c</code> tests if byte <code class="code">c</code> appears in <code class="code">s</code> before
    position <code class="code">stop+1</code>.</p>

<p>Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">stop&nbsp;&lt;&nbsp;0</code> or <code class="code">stop+1</code> is not a valid
    position in <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALuppercase"><span class="keyword">val</span> uppercase</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>Functions operating on Latin-1 character set are deprecated.</div>
<div class="info-desc">
<p>Return a copy of the argument, with all lowercase letters
   translated to uppercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.</p>
</div>
</div>

<pre><span id="VALlowercase"><span class="keyword">val</span> lowercase</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>Functions operating on Latin-1 character set are deprecated.</div>
<div class="info-desc">
<p>Return a copy of the argument, with all uppercase letters
   translated to lowercase, including accented letters of the ISO
   Latin-1 (8859-1) character set.</p>
</div>
</div>

<pre><span id="VALcapitalize"><span class="keyword">val</span> capitalize</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>Functions operating on Latin-1 character set are deprecated.</div>
<div class="info-desc">
<p>Return a copy of the argument, with the first character set to uppercase,
   using the ISO Latin-1 (8859-1) character set..</p>
</div>
</div>

<pre><span id="VALuncapitalize"><span class="keyword">val</span> uncapitalize</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>Functions operating on Latin-1 character set are deprecated.</div>
<div class="info-desc">
<p>Return a copy of the argument, with the first character set to lowercase,
   using the ISO Latin-1 (8859-1) character set..</p>
</div>
</div>

<pre><span id="VALuppercase_ascii"><span class="keyword">val</span> uppercase_ascii</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with all lowercase letters
   translated to uppercase, using the US-ASCII character set.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="VALlowercase_ascii"><span class="keyword">val</span> lowercase_ascii</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with all uppercase letters
   translated to lowercase, using the US-ASCII character set.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="VALcapitalize_ascii"><span class="keyword">val</span> capitalize_ascii</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with the first character set to uppercase,
   using the US-ASCII character set.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="VALuncapitalize_ascii"><span class="keyword">val</span> uncapitalize_ascii</span> : <code class="type">bytes -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with the first character set to lowercase,
   using the US-ASCII character set.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="TYPEt"><span class="keyword">type</span> <code class="type"></code>t</span> = <code class="type">bytes</code> </pre>
<div class="info ">
<div class="info-desc">
<p>An alias for the type of byte sequences.</p>
</div>
</div>


<pre><span id="VALcompare"><span class="keyword">val</span> compare</span> : <code class="type"><a href="Bytes.html#TYPEt">t</a> -> <a href="Bytes.html#TYPEt">t</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>The comparison function for byte sequences, with the same
    specification as <a href="Pervasives.html#VALcompare"><code class="code">compare</code></a>.  Along with the type <code class="code">t</code>,
    this function <code class="code">compare</code> allows the module <code class="code"><span class="constructor">Bytes</span></code> to be passed as
    argument to the functors <a href="Set.Make.html"><code class="code"><span class="constructor">Set</span>.<span class="constructor">Make</span></code></a> and <a href="Map.Make.html"><code class="code"><span class="constructor">Map</span>.<span class="constructor">Make</span></code></a>.</p>
</div>
</div>

<pre><span id="VALequal"><span class="keyword">val</span> equal</span> : <code class="type"><a href="Bytes.html#TYPEt">t</a> -> <a href="Bytes.html#TYPEt">t</a> -> bool</code></pre><div class="info ">
<div class="info-desc">
<p>The equality function for byte sequences.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>
<h4 id="3_Unsafeconversionsforadvancedusers">Unsafe conversions (for advanced users)</h4>
<p>This section describes unsafe, low-level conversion functions
    between <code class="code">bytes</code> and <code class="code">string</code>. They do not copy the internal data;
    used improperly, they can break the immutability invariant on
    strings provided by the <code class="code">-safe-string</code> option. They are available for
    expert library authors, but for most purposes you should use the
    always-correct <a href="Bytes.html#VALto_string"><code class="code"><span class="constructor">Bytes</span>.to_string</code></a> and <a href="Bytes.html#VALof_string"><code class="code"><span class="constructor">Bytes</span>.of_string</code></a> instead.</p>

<pre><span id="VALunsafe_to_string"><span class="keyword">val</span> unsafe_to_string</span> : <code class="type">bytes -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Unsafely convert a byte sequence into a string.</p>

<p>To reason about the use of <code class="code">unsafe_to_string</code>, it is convenient to
    consider an "ownership" discipline. A piece of code that
    manipulates some data "owns" it; there are several disjoint ownership
    modes, including:</p>
<ul>
<li>Unique ownership: the data may be accessed and mutated</li>
<li>Shared ownership: the data has several owners, that may only
      access it, not mutate it.</li>
</ul>
<p>Unique ownership is linear: passing the data to another piece of
    code means giving up ownership (we cannot write the
    data again). A unique owner may decide to make the data shared
    (giving up mutation rights on it), but shared data may not become
    uniquely-owned again.</p>

<p><code class="code">unsafe_to_string&nbsp;s</code> can only be used when the caller owns the byte
   sequence <code class="code">s</code> -- either uniquely or as shared immutable data. The
   caller gives up ownership of <code class="code">s</code>, and gains ownership of the
   returned string.</p>

<p>There are two valid use-cases that respect this ownership
   discipline:</p>

<p>1. Creating a string by initializing and mutating a byte sequence
   that is never changed after initialization is performed.</p>

<pre class="codepre"><code class="code"><span class="keyword">let</span> string_init len f : string =
  <span class="keyword">let</span> s = <span class="constructor">Bytes</span>.create len <span class="keyword">in</span>
  <span class="keyword">for</span> i = 0 <span class="keyword">to</span> len - 1 <span class="keyword">do</span> <span class="constructor">Bytes</span>.set s i (f i) <span class="keyword">done</span>;
  <span class="constructor">Bytes</span>.unsafe_to_string s
   </code></pre>
<p>This function is safe because the byte sequence <code class="code">s</code> will never be
   accessed or mutated after <code class="code">unsafe_to_string</code> is called. The
   <code class="code">string_init</code> code gives up ownership of <code class="code">s</code>, and returns the
   ownership of the resulting string to its caller.</p>

<p>Note that it would be unsafe if <code class="code">s</code> was passed as an additional
   parameter to the function <code class="code">f</code> as it could escape this way and be
   mutated in the future -- <code class="code">string_init</code> would give up ownership of
   <code class="code">s</code> to pass it to <code class="code">f</code>, and could not call <code class="code">unsafe_to_string</code>
   safely.</p>

<p>We have provided the <a href="String.html#VALinit"><code class="code"><span class="constructor">String</span>.init</code></a>, <a href="String.html#VALmap"><code class="code"><span class="constructor">String</span>.map</code></a> and
   <a href="String.html#VALmapi"><code class="code"><span class="constructor">String</span>.mapi</code></a> functions to cover most cases of building
   new strings. You should prefer those over <code class="code">to_string</code> or
   <code class="code">unsafe_to_string</code> whenever applicable.</p>

<p>2. Temporarily giving ownership of a byte sequence to a function
   that expects a uniquely owned string and returns ownership back, so
   that we can mutate the sequence again after the call ended.</p>

<pre class="codepre"><code class="code"><span class="keyword">let</span> bytes_length (s : bytes) =
  <span class="constructor">String</span>.length (<span class="constructor">Bytes</span>.unsafe_to_string s)
   </code></pre>
<p>In this use-case, we do not promise that <code class="code">s</code> will never be mutated
   after the call to <code class="code">bytes_length&nbsp;s</code>. The <a href="String.html#VALlength"><code class="code"><span class="constructor">String</span>.length</code></a> function
   temporarily borrows unique ownership of the byte sequence
   (and sees it as a <code class="code">string</code>), but returns this ownership back to
   the caller, which may assume that <code class="code">s</code> is still a valid byte
   sequence after the call. Note that this is only correct because we
   know that <a href="String.html#VALlength"><code class="code"><span class="constructor">String</span>.length</code></a> does not capture its argument -- it could
   escape by a side-channel such as a memoization combinator.</p>

<p>The caller may not mutate <code class="code">s</code> while the string is borrowed (it has
   temporarily given up ownership). This affects concurrent programs,
   but also higher-order functions: if <a href="String.html#VALlength"><code class="code"><span class="constructor">String</span>.length</code></a> returned
   a closure to be called later, <code class="code">s</code> should not be mutated until this
   closure is fully applied and returns ownership.</p>
</div>
</div>

<pre><span id="VALunsafe_of_string"><span class="keyword">val</span> unsafe_of_string</span> : <code class="type">string -> bytes</code></pre><div class="info ">
<div class="info-desc">
<p>Unsafely convert a shared string to a byte sequence that should
    not be mutated.</p>

<p>The same ownership discipline that makes <code class="code">unsafe_to_string</code>
    correct applies to <code class="code">unsafe_of_string</code>: you may use it if you were
    the owner of the <code class="code">string</code> value, and you will own the return
    <code class="code">bytes</code> in the same mode.</p>

<p>In practice, unique ownership of string values is extremely
    difficult to reason about correctly. You should always assume
    strings are shared, never uniquely owned.</p>

<p>For example, string literals are implicitly shared by the
    compiler, so you never uniquely own them.</p>

<pre class="codepre"><code class="code"><span class="keyword">let</span> incorrect = <span class="constructor">Bytes</span>.unsafe_of_string <span class="string">"hello"</span>
<span class="keyword">let</span> s = <span class="constructor">Bytes</span>.of_string <span class="string">"hello"</span>
    </code></pre>
<p>The first declaration is incorrect, because the string literal
    <code class="code"><span class="string">"hello"</span></code> could be shared by the compiler with other parts of the
    program, and mutating <code class="code">incorrect</code> is a bug. You must always use
    the second version, which performs a copy and is thus correct.</p>

<p>Assuming unique ownership of strings that are not string
    literals, but are (partly) built from string literals, is also
    incorrect. For example, mutating <code class="code">unsafe_of_string&nbsp;(<span class="string">"foo"</span>&nbsp;^&nbsp;s)</code>
    could mutate the shared string <code class="code"><span class="string">"foo"</span></code> -- assuming a rope-like
    representation of strings. More generally, functions operating on
    strings will assume shared ownership, they do not preserve unique
    ownership. It is thus incorrect to assume unique ownership of the
    result of <code class="code">unsafe_of_string</code>.</p>

<p>The only case we have reasonable confidence is safe is if the
    produced <code class="code">bytes</code> is shared -- used as an immutable byte
    sequence. This is possibly useful for incremental migration of
    low-level programs that manipulate immutable sequences of bytes
    (for example <a href="Marshal.html#VALfrom_bytes"><code class="code"><span class="constructor">Marshal</span>.from_bytes</code></a>) and previously used the
    <code class="code">string</code> type for this purpose.</p>
</div>
</div>
</body></html>